home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / vidhrdw / namcos86.c < prev    next >
C/C++ Source or Header  |  2000-04-04  |  12KB  |  434 lines
  1. /*******************************************************************
  2.  
  3. Rolling Thunder Video Hardware
  4.  
  5. *******************************************************************/
  6.  
  7. #include "driver.h"
  8.  
  9.  
  10. #define GFX_TILES1    0
  11. #define GFX_TILES2    1
  12. #define GFX_SPRITES    2
  13.  
  14. unsigned char *rthunder_videoram1,*rthunder_videoram2;
  15. extern unsigned char *spriteram;
  16.  
  17. static int tilebank;
  18. static int xscroll[4], yscroll[4];    /* scroll + priority */
  19.  
  20. static struct tilemap *tilemap[4];
  21.  
  22. static int backcolor;
  23. static int flipscreen;
  24. static const unsigned char *tile_address_prom;
  25.  
  26.  
  27. /***************************************************************************
  28.  
  29.   Convert the color PROMs into a more useable format.
  30.  
  31.   Rolling Thunder has two palette PROMs (512x8 and 512x4) and two 2048x8
  32.   lookup table PROMs.
  33.   The palette PROMs are connected to the RGB output this way:
  34.  
  35.   bit 3 -- 220 ohm resistor  -- BLUE
  36.         -- 470 ohm resistor  -- BLUE
  37.         -- 1  kohm resistor  -- BLUE
  38.   bit 0 -- 2.2kohm resistor  -- BLUE
  39.  
  40.   bit 7 -- 220 ohm resistor  -- GREEN
  41.         -- 470 ohm resistor  -- GREEN
  42.         -- 1  kohm resistor  -- GREEN
  43.         -- 2.2kohm resistor  -- GREEN
  44.         -- 220 ohm resistor  -- RED
  45.         -- 470 ohm resistor  -- RED
  46.         -- 1  kohm resistor  -- RED
  47.   bit 0 -- 2.2kohm resistor  -- RED
  48.  
  49. ***************************************************************************/
  50.  
  51. void namcos86_vh_convert_color_prom( unsigned char *palette,unsigned short *colortable,const unsigned char *color_prom )
  52. {
  53.     int i;
  54.     int totcolors,totlookup;
  55.  
  56.  
  57.     totcolors = Machine->drv->total_colors;
  58.     totlookup = Machine->drv->color_table_len;
  59.  
  60.     for (i = 0;i < totcolors;i++)
  61.     {
  62.         int bit0,bit1,bit2,bit3;
  63.  
  64.  
  65.         bit0 = (color_prom[0] >> 0) & 0x01;
  66.         bit1 = (color_prom[0] >> 1) & 0x01;
  67.         bit2 = (color_prom[0] >> 2) & 0x01;
  68.         bit3 = (color_prom[0] >> 3) & 0x01;
  69.         *(palette++) = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  70.         bit0 = (color_prom[0] >> 4) & 0x01;
  71.         bit1 = (color_prom[0] >> 5) & 0x01;
  72.         bit2 = (color_prom[0] >> 6) & 0x01;
  73.         bit3 = (color_prom[0] >> 7) & 0x01;
  74.         *(palette++) = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  75.         bit0 = (color_prom[totcolors] >> 0) & 0x01;
  76.         bit1 = (color_prom[totcolors] >> 1) & 0x01;
  77.         bit2 = (color_prom[totcolors] >> 2) & 0x01;
  78.         bit3 = (color_prom[totcolors] >> 3) & 0x01;
  79.         *(palette++) = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  80.  
  81.         color_prom++;
  82.     }
  83.  
  84.     color_prom += totcolors;
  85.     /* color_prom now points to the beginning of the lookup table */
  86.  
  87.     /* tiles lookup table */
  88.     for (i = 0;i < totlookup/2;i++)
  89.         *(colortable++) = *color_prom++;
  90.  
  91.     /* sprites lookup table */
  92.     for (i = 0;i < totlookup/2;i++)
  93.         *(colortable++) = *(color_prom++) + totcolors/2;
  94.  
  95.     /* color_prom now points to the beginning of the tile address decode PROM */
  96.  
  97.     tile_address_prom = color_prom;    /* we'll need this at run time */
  98. }
  99.  
  100.  
  101.  
  102.  
  103. /***************************************************************************
  104.  
  105.   Callbacks for the TileMap code
  106.  
  107. ***************************************************************************/
  108.  
  109. static unsigned char *videoram;
  110. static int gfx_num;
  111. static int tile_offs[4];
  112.  
  113. static void tilemap0_preupdate(void)
  114. {
  115.     videoram = &rthunder_videoram1[0x0000];
  116.     gfx_num = GFX_TILES1;
  117.     tile_offs[0] = ((tile_address_prom[0x00] & 0x0e) >> 1) * 0x100 + tilebank * 0x800;
  118.     tile_offs[1] = ((tile_address_prom[0x04] & 0x0e) >> 1) * 0x100 + tilebank * 0x800;
  119.     tile_offs[2] = ((tile_address_prom[0x08] & 0x0e) >> 1) * 0x100 + tilebank * 0x800;
  120.     tile_offs[3] = ((tile_address_prom[0x0c] & 0x0e) >> 1) * 0x100 + tilebank * 0x800;
  121. }
  122.  
  123. static void tilemap1_preupdate(void)
  124. {
  125.     videoram = &rthunder_videoram1[0x1000];
  126.     gfx_num = GFX_TILES1;
  127.     tile_offs[0] = ((tile_address_prom[0x10] & 0x0e) >> 1) * 0x100 + tilebank * 0x800;
  128.     tile_offs[1] = ((tile_address_prom[0x14] & 0x0e) >> 1) * 0x100 + tilebank * 0x800;
  129.     tile_offs[2] = ((tile_address_prom[0x18] & 0x0e) >> 1) * 0x100 + tilebank * 0x800;
  130.     tile_offs[3] = ((tile_address_prom[0x1c] & 0x0e) >> 1) * 0x100 + tilebank * 0x800;
  131. }
  132.  
  133. static void tilemap2_preupdate(void)
  134. {
  135.     videoram = &rthunder_videoram2[0x0000];
  136.     gfx_num = GFX_TILES2;
  137.     tile_offs[0] = ((tile_address_prom[0x00] & 0xe0) >> 5) * 0x100;
  138.     tile_offs[1] = ((tile_address_prom[0x01] & 0xe0) >> 5) * 0x100;
  139.     tile_offs[2] = ((tile_address_prom[0x02] & 0xe0) >> 5) * 0x100;
  140.     tile_offs[3] = ((tile_address_prom[0x03] & 0xe0) >> 5) * 0x100;
  141. }
  142.  
  143. static void tilemap3_preupdate(void)
  144. {
  145.     videoram = &rthunder_videoram2[0x1000];
  146.     gfx_num = GFX_TILES2;
  147.     tile_offs[0] = ((tile_address_prom[0x10] & 0xe0) >> 5) * 0x100;
  148.     tile_offs[1] = ((tile_address_prom[0x11] & 0xe0) >> 5) * 0x100;
  149.     tile_offs[2] = ((tile_address_prom[0x12] & 0xe0) >> 5) * 0x100;
  150.     tile_offs[3] = ((tile_address_prom[0x13] & 0xe0) >> 5) * 0x100;
  151. }
  152.  
  153. static void get_tile_info(int tile_index)
  154. {
  155.     unsigned char attr = videoram[2*tile_index + 1];
  156.     SET_TILE_INFO(gfx_num,videoram[2*tile_index] + tile_offs[attr & 0x03],attr)
  157. }
  158.  
  159.  
  160.  
  161. /***************************************************************************
  162.  
  163.   Start the video hardware emulation.
  164.  
  165. ***************************************************************************/
  166.  
  167. int namcos86_vh_start(void)
  168. {
  169.     tilemap[0] = tilemap_create(get_tile_info,tilemap_scan_rows,TILEMAP_TRANSPARENT,8,8,64,32);
  170.     tilemap[1] = tilemap_create(get_tile_info,tilemap_scan_rows,TILEMAP_TRANSPARENT,8,8,64,32);
  171.     tilemap[2] = tilemap_create(get_tile_info,tilemap_scan_rows,TILEMAP_TRANSPARENT,8,8,64,32);
  172.     tilemap[3] = tilemap_create(get_tile_info,tilemap_scan_rows,TILEMAP_TRANSPARENT,8,8,64,32);
  173.  
  174.     if (!tilemap[0] || !tilemap[1] || !tilemap[2] || !tilemap[3])
  175.         return 1;
  176.  
  177.     tilemap[0]->transparent_pen = 7;
  178.     tilemap[1]->transparent_pen = 7;
  179.     tilemap[2]->transparent_pen = 7;
  180.     tilemap[3]->transparent_pen = 7;
  181.  
  182.     return 0;
  183. }
  184.  
  185.  
  186.  
  187. /***************************************************************************
  188.  
  189.   Memory handlers
  190.  
  191. ***************************************************************************/
  192.  
  193. READ_HANDLER( rthunder_videoram1_r )
  194. {
  195.     return rthunder_videoram1[offset];
  196. }
  197.  
  198. WRITE_HANDLER( rthunder_videoram1_w )
  199. {
  200.     if (rthunder_videoram1[offset] != data)
  201.     {
  202.         rthunder_videoram1[offset] = data;
  203.         tilemap_mark_tile_dirty(tilemap[offset/0x1000],(offset & 0xfff)/2);
  204.     }
  205. }
  206.  
  207. READ_HANDLER( rthunder_videoram2_r )
  208. {
  209.     return rthunder_videoram2[offset];
  210. }
  211.  
  212. WRITE_HANDLER( rthunder_videoram2_w )
  213. {
  214.     if (rthunder_videoram2[offset] != data)
  215.     {
  216.         rthunder_videoram2[offset] = data;
  217.         tilemap_mark_tile_dirty(tilemap[2+offset/0x1000],(offset & 0xfff)/2);
  218.     }
  219. }
  220.  
  221. WRITE_HANDLER( rthunder_tilebank_select_0_w )
  222. {
  223.     if (tilebank != 0)
  224.     {
  225.         tilebank = 0;
  226.         tilemap_mark_all_tiles_dirty(tilemap[0]);
  227.         tilemap_mark_all_tiles_dirty(tilemap[1]);
  228.     }
  229. }
  230.  
  231. WRITE_HANDLER( rthunder_tilebank_select_1_w )
  232. {
  233.     if (tilebank != 1)
  234.     {
  235.         tilebank = 1;
  236.         tilemap_mark_all_tiles_dirty(tilemap[0]);
  237.         tilemap_mark_all_tiles_dirty(tilemap[1]);
  238.     }
  239. }
  240.  
  241. static void scroll_w(int layer,int offset,int data)
  242. {
  243.     int xdisp[4] = { 36,34,37,35 };
  244.     int ydisp = 9;
  245.     int scrollx,scrolly;
  246.  
  247.  
  248.     switch (offset)
  249.     {
  250.         case 0:
  251.             xscroll[layer] = (xscroll[layer]&0xff)|(data<<8);
  252.             break;
  253.         case 1:
  254.             xscroll[layer] = (xscroll[layer]&0xff00)|data;
  255.             break;
  256.         case 2:
  257.             yscroll[layer] = data;
  258.             break;
  259.     }
  260.  
  261.     scrollx = xscroll[layer]+xdisp[layer];
  262.     scrolly = yscroll[layer]+ydisp;
  263.     if (flipscreen)
  264.     {
  265.         scrollx = -scrollx+256;
  266.         scrolly = -scrolly;
  267.     }
  268.     tilemap_set_scrollx(tilemap[layer],0,scrollx-16);
  269.     tilemap_set_scrolly(tilemap[layer],0,scrolly+16);
  270. }
  271.  
  272. WRITE_HANDLER( rthunder_scroll0_w )
  273. {
  274.     scroll_w(0,offset,data);
  275. }
  276. WRITE_HANDLER( rthunder_scroll1_w )
  277. {
  278.     scroll_w(1,offset,data);
  279. }
  280. WRITE_HANDLER( rthunder_scroll2_w )
  281. {
  282.     scroll_w(2,offset,data);
  283. }
  284. WRITE_HANDLER( rthunder_scroll3_w )
  285. {
  286.     scroll_w(3,offset,data);
  287. }
  288.  
  289.  
  290. WRITE_HANDLER( rthunder_backcolor_w )
  291. {
  292.     backcolor = data;
  293. }
  294.  
  295.  
  296. /***************************************************************************
  297.  
  298.   Display refresh
  299.  
  300. ***************************************************************************/
  301.  
  302. static void draw_sprites( struct osd_bitmap *bitmap, int sprite_priority )
  303. {
  304.     /* note: sprites don't yet clip at the top of the screen properly */
  305.     const struct rectangle *clip = &Machine->drv->visible_area;
  306.  
  307.     const unsigned char *source = &spriteram[0x1400];
  308.     const unsigned char *finish = &spriteram[0x1c00-16];    /* the last is NOT a sprite */
  309.  
  310.     int sprite_xoffs = spriteram[0x1bf5] - 256 * (spriteram[0x1bf4] & 1);
  311.     int sprite_yoffs = spriteram[0x1bf7] - 256 * (spriteram[0x1bf6] & 1);
  312.  
  313.     while( source<finish )
  314.     {
  315. /*
  316.     source[4]    S-FT -BBB
  317.     source[5]    TTTT TTTT
  318.     source[6]   CCCC CCCX
  319.     source[7]    XXXX XXXX
  320.     source[8]    PPPT -S-F
  321.     source[9]   YYYY YYYY
  322. */
  323.         unsigned char priority = source[8];
  324.         if( priority>>5 == sprite_priority )
  325.         {
  326.             unsigned char attrs = source[4];
  327.             unsigned char color = source[6];
  328.             int sx = source[7] + (color&1)*256; /* need adjust for left clip */
  329.             int sy = -source[9];
  330.             int flipx = attrs&0x20;
  331.             int flipy = priority & 0x01;
  332.             int tall = (priority&0x04)?1:0;
  333.             int wide = (attrs&0x80)?1:0;
  334.             int sprite_bank = attrs&7;
  335.             int sprite_number = (source[5]&0xff)*4;
  336.             int row,col;
  337.  
  338.             if ((attrs & 0x10) && !wide) sprite_number += 1;
  339.             if ((priority & 0x10) && !tall) sprite_number += 2;
  340.             color = color>>1;
  341.  
  342.             if (sx>512-32) sx -= 512;
  343.             if (sy < -209-32) sy += 256;
  344.  
  345.             if (flipx && !wide) sx-=16;
  346.             if (!tall) sy+=16;
  347. //            if (flipy && !tall) sy+=16;
  348.  
  349.             sx += sprite_xoffs;
  350.             sy -= sprite_yoffs;
  351.  
  352.             for( row=0; row<=tall; row++ )
  353.             {
  354.                 for( col=0; col<=wide; col++ )
  355.                 {
  356.                     if (flipscreen)
  357.                     {
  358.                         drawgfx( bitmap, Machine->gfx[GFX_SPRITES+sprite_bank],
  359.                             sprite_number+2*row+col,
  360.                             color,
  361.                             !flipx,!flipy,
  362.                             512-16-67 - (sx+16*(flipx?1-col:col)),
  363.                             64-16+209 - (sy+16*(flipy?1-row:row)),
  364.                             clip,
  365.                             TRANSPARENCY_PEN, 0xf );
  366.                     }
  367.                     else
  368.                     {
  369.                         drawgfx( bitmap, Machine->gfx[GFX_SPRITES+sprite_bank],
  370.                             sprite_number+2*row+col,
  371.                             color,
  372.                             flipx,flipy,
  373.                             -67 + (sx+16*(flipx?1-col:col)),
  374.                             209 + (sy+16*(flipy?1-row:row)),
  375.                             clip,
  376.                             TRANSPARENCY_PEN, 0xf );
  377.                     }
  378.                 }
  379.             }
  380.         }
  381.         source+=16;
  382.     }
  383. }
  384.  
  385.  
  386.  
  387. void namcos86_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
  388. {
  389.     int layer;
  390.  
  391.     /* this is the global sprite Y offset, actually */
  392.     flipscreen = spriteram[0x1bf6] & 1;
  393.  
  394.     tilemap_set_flip(ALL_TILEMAPS,flipscreen ? (TILEMAP_FLIPY | TILEMAP_FLIPX) : 0);
  395.  
  396.     tilemap0_preupdate(); tilemap_update(tilemap[0]);
  397.     tilemap1_preupdate(); tilemap_update(tilemap[1]);
  398.     tilemap2_preupdate(); tilemap_update(tilemap[2]);
  399.     tilemap3_preupdate(); tilemap_update(tilemap[3]);
  400.  
  401.     tilemap_render(ALL_TILEMAPS);
  402.  
  403.     fillbitmap(bitmap,Machine->gfx[0]->colortable[8*backcolor+7],&Machine->drv->visible_area);
  404.  
  405.     for (layer = 0;layer < 8;layer++)
  406.     {
  407.         int i;
  408.  
  409.         for (i = 3;i >= 0;i--)
  410.         {
  411.             if (((xscroll[i] & 0x0e00) >> 9) == layer)
  412.                 tilemap_draw(bitmap,tilemap[i],0);
  413.         }
  414.  
  415.         draw_sprites(bitmap,layer);
  416.     }
  417. #if 0
  418. {
  419.     char buf[80];
  420. int b=keyboard_pressed(KEYCODE_Y)?8:0;
  421.     sprintf(buf,"%02x %02x %02x %02x %02x %02x %02x %02x",
  422.             spriteram[0x1bf0+b],
  423.             spriteram[0x1bf1+b],
  424.             spriteram[0x1bf2+b],
  425.             spriteram[0x1bf3+b],
  426.             spriteram[0x1bf4+b],
  427.             spriteram[0x1bf5+b],
  428.             spriteram[0x1bf6+b],
  429.             spriteram[0x1bf7+b]);
  430.     usrintf_showmessage(buf);
  431. }
  432. #endif
  433. }
  434.